dmdscript - the EMCAScript (javascript) engine in D - adding objects

(This assumes you have worked out how to download and install dmdscript)

Step 1 - Modify the testscript.d file.

First step is to make reference to your new classes in the 'main()' file which for dmdscript is testscript, a simple wrapper around the engine that deals with the command line interpretation. At the bottom of the file is a class called SrcFile that wraps the file[s] being included. The trick is to add call to your method that adds all your classes to the global scope.

import dtest; <<< Import the file/module that has your init code..

void compile() {
	program = new Program();
	Dtest_init(program.callcontext); <<<< Added.
	program.compile(srcfile, buffer, null);
}

Step 2 - register all the new classes you need.

I came to the conclusion that a simple method would do for this. - rather than init functions in the classes, which is what the examples in dmdscript showed.

// register all the classes in this file..
static void Dtest_init(CallContext* cc) {
	ThreadContext *tc = ThreadContext.getThreadContext();
	
	// add constructor and prototype to our global list 
	// used so we can quickly access prototypes by looking the up.

	// NOTE: you must make the constructor first, as the prototype 
	// this() method looks up on the ctorTable.. 
	tc.ctorTable["test"] = new Dtest_Constructor(tc);
	tc.protoTable["test"] = new Dtest_prototype(tc);
	
	
	// Now actually register the WORD 'test' in the global namespace
	cc.global.Put("test", tc.ctorTable["test"], DontEnum);
	

	// add "test.prototype" 
	tc.ctorTable["test"].Put("prototype", tc.protoTable["test"],
		 DontEnum | DontDelete | ReadOnly);
	
	
	// THIS IS FOR "new test.test()"
	
	
	// first just store the constructor and prototype in the lookup table.
	// AFAIK It's only put here so it can be quickly retrieved later..
	// so the index name is not really that important.
	tc.ctorTable["test.test"] = new Dtest_test_Constructor(tc);
	tc.protoTable["test.test"] = new Dtest_test_prototype(tc);
	
	
	// add the prototype "test.test.prototype.*" 
	tc.ctorTable["test.test"].Put("prototype", tc.protoTable["test.test"],
		 DontEnum | DontDelete | ReadOnly);
		 
	// now add the constructor to "test.test" , basically it adds the
	// "test" property to the "test" constructor object.
	tc.ctorTable["test"].Put("test", tc.ctorTable["test.test"] , 0);
	
}

Step 3 - Define The constructor Object.

The constructor function, (builds on the standard Javascript function, with the key difference that it contains a Construct method, that returns the new object.

• The new object has to have the Dobject interface (hence it just extends it.)

The this() constructor is responsible for creating all the *static* methods of the class: eg. test.testworld2(). I've put all the actual implementations of these in the Dtest class. The dmdscript source usually just makes the functions (rather than static methods), but I think it saves a bit typing (eg. a prefix), and seems more natrual to actually have them defined in the class they are used with.

The logic behind this is simple - test() is a function, (which is also a constructor). test.testworld() is created by adding a property testworld to the function test(), and connecting it to a function.

class Dtest_Constructor : Dfunction
{
		
	// register static methods..
	this(ThreadContext *tc)
	{
		super(7, tc.Dfunction_prototype);
		this.name = "test";
		this.Put("testworld2", 
			new DnativeFunction(
				&Dtest.testworld2, "testworld2", 0, Dfunction.getPrototype()
			), 0);
	}
	
	// our constructor - called when new test() is called, must return an
	// object. of type Dobject in the ret Value.;
	void *Construct(CallContext *cc, Value *ret, Value[] arglist)
	{
		Dobject o;
		o = new Dtest(); // can this be automated??
		ret.putVobject(o);
		return null;
		
	}
	 
}

Step 4 - Create a prototype

The prototype object is an extension of the main object (although I'm not 100% sure on the logic or necessity of this pattern at present).

It's purpose is to register the constructor

test.prototype.constructor()

and all the prototype properties.
eg.

test.prototype.testworld()

Which can also be used as

var a = new test; a.testworld();

or

test.prototype.testworld.call(new test());

and on and on....

Note the super() call which calls into the parent (which should set the classname variable.)

class Dtest_prototype : Dtest
{
  // we register all our methods in here..
	this(ThreadContext *tc)
    {
		super(tc.Dobject_prototype); // which assigns classname
		
		this.Put(TEXT_constructor, tc.ctorTable[this.classname], DontEnum);
		this.Put("testworld", 
			new DnativeFunction(
				&Dtest.testworld, "testworld", 0, Dfunction.getPrototype()
			), 0);
		
		this.Put("query", 
			new DnativeFunction(
				&Dtest.query, "query", 0, Dfunction.getPrototype()
			), 0);
	    
    }
}

Step 5 - Finally create the object.

As per usual create the class wrapper, that must extend Dobject.. - so it can be passed around

class Dtest: Dobject 
{

Next Define all the static and instance methods (they are pretty much the same, and you can use the same real method to implement both for javascript)


Next the general prototype extension call.

	// our instance methods..
    static void* testworld( Dobject pthis, CallContext* cc, Dobject othis, Value* ret, Value[] arglist) 
	{
		ret.putVstring("Hello World");
		return null;
	}
	
	static void* query( Dobject pthis, CallContext* cc, Dobject othis, Value* ret, Value[] arglist) 
	{
		int ret = mysql_query((cast(Dtest)othis).con, "select * from test");
		return null;
	}
	
	
	// our static methods..
	static void* testworld2( Dobject pthis, CallContext* cc, Dobject othis, Value* ret, Value[] arglist) 
	{
		ret.putVstring("Hello World2");
		return null;
	}  

Next the general constructor used by the prototype extension call.

    this(Dobject prototype)  
    {
        super(prototype);
        this.classname = "test";
    }

Now for the magic part. The class constructor that is called when you really create a new object in Javascript - The trick being, that if you are wrapping an object (or pointer of some other class - GD, Mysql , Gtc etc. you create the pointer here.. and any method of the object - in this conceptial example I've wrapped mysql connection, and shown how to retrieve it earlier.

    Mysqlconnection con;
	
    this() // called when new Object is created...
    {
	ThreadContext *tc = ThreadContext.getThreadContext();
	super( tc.protoTable["test"]);
	this.classname = "test";
	mysql_connect(con);
    }    
}

And finally, you will need to import all the required libs to make this work..

import dmdscript.dobject;
import dmdscript.value;
import dmdscript.script;
import dmdscript.dnative;
import dmdscript.property;
import dmdscript.threadcontext;
import dmdscript.dfunction;
import dmdscript.text;

Well, let's see If I get time to play with this more, As you can see, binding libraries is considerably simpler than any other of the P* languages....